Dynamic Data Structures for k-Nearest Neighbor Queries

Our aim is to develop dynamic data structures that support $k$-nearest neighbors ($k$-NN) queries for a set of $n$ point sites in the plane in $O(f(n) + k)$ time, where $f(n)$ is some polylogarithmic function of $n$. The key component is a general query algorithm that allows us to find the $k$-NN spread over $t$ substructures simultaneously, thus reducing an $O(tk)$ term in the query time to $O(k)$. Combining this technique with the logarithmic method allows us to turn any static $k$-NN data structure into a data structure supporting both efficient insertions and queries. For the fully dynamic case, this technique allows us to recover the deterministic, worst-case, $O(\log^2n/\log\log n +k)$ query time for the Euclidean distance claimed before, while preserving the polylogarithmic update times. We adapt this data structure to also support fully dynamic \emph{geodesic} $k$-NN queries among a set of sites in a simple polygon. For this purpose, we design a shallow cutting based, deletion-only $k$-NN data structure. More generally, we obtain a dynamic planar $k$-NN data structure for any type of distance functions for which we can build vertical shallow cuttings. We apply all of our methods in the plane for the Euclidean distance, the geodesic distance, and general, constant-complexity, algebraic distance functions

Dynamic data structures for k-nearest neighbor queries

Our aim is to develop dynamic data structures that support k-nearest neighbors (k-NN) queries for a set of n point sites in the plane in O(f(n)+k) time, where f(n) is some polylogarithmic function of n. The key component is a general query algorithm that allows us to find the k-NN spread over t substructures simultaneously, thus reducing an O(tk) term in the query time to O(k). Combining this technique with the logarithmic method allows us to turn any static k-NN data structure into a data structure supporting both efficient insertions and queries. For the fully dynamic case, this technique allows us to recover the deterministic, worst-case, O(log2⁡n/log⁡log⁡n+k) query time for the Euclidean distance claimed before, while preserving the polylogarithmic update times. We adapt this data structure to also support fully dynamic geodesic k-NN queries among a set of sites in a simple polygon. For this purpose, we design a shallow cutting based, deletion-only k-NN data structure. More generally, we obtain a dynamic planar k-NN data structure for any type of distance functions for which we can build vertical shallow cuttings. We apply all of our methods in the plane for the Euclidean distance, the geodesic distance, and general, constant-complexity, algebraic distance functions

Towards Space Efficient Two-Point Shortest Path Queries in a Polygonal Domain

We devise a data structure that can answer shortest path queries for two query points in a polygonal domain P on n vertices. For any ε>0, the space complexity of the data structure is O(n10+ε) and queries can be answered in O(logn) time. Alternatively, we can achieve a space complexity of O(n9+ε) by relaxing the query time to O(log2n). This is the first improvement upon a conference paper by Chiang and Mitchell from 1999. They present a data structure with O(n11) space complexity and O(logn) query time. Our main result can be extended to include a space-time trade-off. Specifically, we devise data structures with O(n9+ε/ℓ4+O(ε)) space complexity and O(ℓlog2n) query time, for any integer 1≤ℓ≤n. Furthermore, we present improved data structures with O(logn) query time for the special case where we restrict one (or both) of the query points to lie on the boundary of P. When one of the query points is restricted to lie on the boundary, and the other query point is unrestricted, the space complexity becomes O(n6+ε). When both query points are on the boundary, the space complexity is decreased further to O(n4+ε), thereby improving an earlier result of Bae and Okamoto

The Complexity of Geodesic Spanners

A geometric t-spanner for a set S of n point sites is an edge-weighted graph for which the (weighted) distance between any two sites p, q ∈ S is at most t times the original distance between p and q. We study geometric t-spanners for point sets in a constrained two-dimensional environment P. In such cases, the edges of the spanner may have non-constant complexity. Hence, we introduce a novel spanner property: the spanner complexity, that is, the total complexity of all edges in the spanner. Let S be a set of n point sites in a simple polygon P with m vertices. We present an algorithm to construct, for any constant ε > 0 and fixed integer k ≥ 1, a (2k + ε)-spanner with complexity O(mn1/k + n log2 n) in O(n log2 n + m log n + K) time, where K denotes the output complexity. When we consider sites in a polygonal domain P with holes, we can construct such a (2k + ε)-spanner of similar complexity in O(n2 log m + nm log m + K) time. Additionally, for any constant ε ∈ (0, 1) and integer constant t ≥ 2, we show a lower bound for the complexity of any (t − ε)-spanner of (Equation presented)

A Dynamic Data Structure for k-Nearest Neighbors Queries

We present an insertion-only data structure that supports k-nearest neighbors queries for a set of n point sites in O(Q(n)log n + k) time, based on any static data structure that can perform k 0 -nearest neighbors queries in O(Q(n) + k 0 ) time. The key component is a general query algorithm that allows us to find k-nearest neighbors spread over t substructures simultaneously, thus reducing the O(tk) term in the query time to O(k). Applying this to the logarithmic method yields an insertion-only data structure with both efficient insertion and query time. We apply our method in the plane for the Euclidean and geodesic distance. We then briefly discuss the main difficulties to achieve a similar running time in the fully dynamic case

A Dynamic Data Structure for k-Nearest Neighbors Queries

We present an insertion-only data structure that supports k-nearest neighbors queries for a set of n point sites in O(Q(n)log n + k) time, based on any static data structure that can perform k 0 -nearest neighbors queries in O(Q(n) + k 0 ) time. The key component is a general query algorithm that allows us to find k-nearest neighbors spread over t substructures simultaneously, thus reducing the O(tk) term in the query time to O(k). Applying this to the logarithmic method yields an insertion-only data structure with both efficient insertion and query time. We apply our method in the plane for the Euclidean and geodesic distance. We then briefly discuss the main difficulties to achieve a similar running time in the fully dynamic case

Dynamic data structures for k-nearest neighbor queries

Our aim is to develop dynamic data structures that support k-nearest neighbors (k-NN) queries for a set of n point sites in the plane in O(f(n)+k) time, where f(n) is some polylogarithmic function of n. The key component is a general query algorithm that allows us to find the k-NN spread over t substructures simultaneously, thus reducing an O(tk) term in the query time to O(k). Combining this technique with the logarithmic method allows us to turn any static k-NN data structure into a data structure supporting both efficient insertions and queries. For the fully dynamic case, this technique allows us to recover the deterministic, worst-case, O(log2⁡n/log⁡log⁡n+k) query time for the Euclidean distance claimed before, while preserving the polylogarithmic update times. We adapt this data structure to also support fully dynamic geodesic k-NN queries among a set of sites in a simple polygon. For this purpose, we design a shallow cutting based, deletion-only k-NN data structure. More generally, we obtain a dynamic planar k-NN data structure for any type of distance functions for which we can build vertical shallow cuttings. We apply all of our methods in the plane for the Euclidean distance, the geodesic distance, and general, constant-complexity, algebraic distance functions

Dynamic Data Structures for k-Nearest Neighbor Queries

Our aim is to develop dynamic data structures that support k-nearest neighbors (k-NN) queries for a set of n point sites in O(f(n) + k) time, where f(n) is some polylogarithmic function of n. The key component is a general query algorithm that allows us to find the k-NN spread over t substructures simultaneously, thus reducing a O(tk) term in the query time to O(k). Combining this technique with the logarithmic method allows us to turn any static k-NN data structure into a data structure supporting both efficient insertions and queries. For the fully dynamic case, this technique allows us to recover the deterministic, worst-case, O(log²n/log log n +k) query time for the Euclidean distance claimed before, while preserving the polylogarithmic update times. We adapt this data structure to also support fully dynamic geodesic k-NN queries among a set of sites in a simple polygon. For this purpose, we design a shallow cutting based, deletion-only k-NN data structure. More generally, we obtain a dynamic k-NN data structure for any type of distance functions for which we can build vertical shallow cuttings. We apply all of our methods in the plane for the Euclidean distance, the geodesic distance, and general, constant-complexity, algebraic distance functions

Dynamic Data Structures for k-Nearest Neighbor Queries

Our aim is to develop dynamic data structures that support k-nearest neighbors (k-NN) queries for a set of n point sites in O(f(n) + k) time, where f(n) is some polylogarithmic function of n. The key component is a general query algorithm that allows us to find the k-NN spread over t substructures simultaneously, thus reducing a O(tk) term in the query time to O(k). Combining this technique with the logarithmic method allows us to turn any static k-NN data structure into a data structure supporting both efficient insertions and queries. For the fully dynamic case, this technique allows us to recover the deterministic, worst-case, O(log²n/log log n +k) query time for the Euclidean distance claimed before, while preserving the polylogarithmic update times. We adapt this data structure to also support fully dynamic geodesic k-NN queries among a set of sites in a simple polygon. For this purpose, we design a shallow cutting based, deletion-only k-NN data structure. More generally, we obtain a dynamic k-NN data structure for any type of distance functions for which we can build vertical shallow cuttings. We apply all of our methods in the plane for the Euclidean distance, the geodesic distance, and general, constant-complexity, algebraic distance functions